home *** CD-ROM | disk | FTP | other *** search
/ Amiga Developer CD 2.1 / Amiga Developer CD v2.1.iso / Reference / Amiga_Mail_Vol2 / Archives / Plain / so92 / SIGF_SINGLE / SIGF_Single.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-02  |  4.7 KB  |  115 lines
  1. ;/* SIGF_Single.c - Execute me to compile me with SAS C 5.10b
  2. LC -b1 -cfist -v -y -j73 SIGF_Single.c
  3. Blink FROM LIB:c.o,SIGF_Single.o TO SIGF_Single LIBRARY LIB:LC.lib,LIB:Amiga.lib
  4. quit ;*/
  5.  
  6. /*
  7. (c)  Copyright 1992 Commodore-Amiga, Inc.   All rights reserved.
  8. The information contained herein is subject to change without notice,
  9. and is provided "as is" without warranty of any kind, either expressed
  10. or implied.  The entire risk as to the use of this information is
  11. assumed by the user.
  12. */
  13.  
  14. /* This example program illustrates simple usage of the SIGF_SINGLE */
  15. /* signal for "single shot" signalling.  This signal is one of the  */
  16. /* system private signals, but applications can use it in certain   */
  17. /* cases, but only if used carefully.  Specifically, applications   */
  18. /* should use it only to Wait() on, and using only that signal      */
  19. /* (applications cannot Wait() on other signals in the same         */
  20. /* Wait()).  Not following these rules can cause serious system     */
  21. /* problems. For more details, see the Amiga Mail article,          */
  22. /* "Signalling with SIGF_SINGLE" from the September/October 1992    */
  23. /* issue of Amiga Mail.                                             */
  24.  
  25. #include <exec/types.h>
  26. #include <exec/memory.h>
  27. #include <dos/dosextens.h>
  28. #include <dos/dostags.h>
  29.  
  30. #include <clib/exec_protos.h>
  31. #include <clib/dos_protos.h>
  32. #include <clib/alib_protos.h>
  33. #include "stdio.h"
  34.  
  35. #ifdef LATTICE
  36. int CXBRK(void) { return(0); }     /* Disable Lattice CTRL/C handling. */
  37. int chkabort(void) { return(0); }  /* really */
  38. #endif
  39.  
  40. static UBYTE *VersTag = "$VER: SIGF_Single 38.7 (21.9.92)";
  41.  
  42. void childprocesscode(void);      /* prototype for our childprocess routine. */
  43.  
  44. struct Process *mainprocess = NULL, *childprocess = NULL;
  45. UBYTE childprocessname[] = "RKM_signal_childprocess";
  46.  
  47. BPTR output;
  48.  
  49. void main(int argc, char **argv)
  50. {
  51.     if (output = Open("*", MODE_OLDFILE))       /* Open the console for the  */
  52.                                                 /*            child process. */
  53.     {
  54.         mainprocess = (struct Process *)FindTask(NULL);/* childprocess can   */
  55.                                                        /* access this global.*/
  56.  
  57.         if (childprocess = CreateNewProcTags(
  58.                     NP_Entry,       childprocesscode,  /* The child process  */
  59.                     NP_StackSize,   2000L,             /*              code. */
  60.                     NP_Name,        childprocessname,
  61.                     NP_Output,      output,
  62.                     NP_FreeSeglist, FALSE,
  63.                     NP_CloseOutput, TRUE,
  64.                     TAG_DONE,       0L))
  65.  
  66.         {                                   /* I split the PutStr() into two */
  67.             PutStr("Main Process: Created a child process"); /* to fit code  */
  68.             PutStr(" and waiting on SIGF_SINGLE.\n");        /* on an 8.5 by */
  69.                                                              /* 11 page.     */
  70.  
  71.             Flush(Output());    /* Make sure the PutStr() above appears      */
  72.                                 /* in the console window before the child    */
  73.                                 /* process start PutStr()ing to the console. */
  74.  
  75.             SetSignal(0L, SIGF_SINGLE);        /* Use SIGF_SINGLE only after */
  76.                                                /* clearing it.               */
  77.             Wait(SIGF_SINGLE);     /* Only use SIGF_SINGLE for Wait()ing and */
  78.                                    /* Wait on that signal alone!             */
  79.  
  80.             PutStr("Main Process: Received signal from child.\n");
  81.         }
  82.         else
  83.             PutStr("Main Process: Can't create child process. Exiting.\n");
  84.     }
  85.     else
  86.         PutStr("Main Process: Can't open CON:.  Exiting.\n");
  87. }
  88.  
  89. void childprocesscode(void)     /* This function is what CreateNewProcTags() */
  90. {                               /* loads as the child process.  This child   */
  91.                                 /* signals the parent using SIGF_SINGLE.     */
  92.     ULONG x;
  93.  
  94.     PutStr("Child Process: I'm alive and starting a 5 second TimeDelay()");
  95.     Flush(Output());
  96.  
  97.     for (x = 0; x < 5; x++)
  98.     {
  99.         TimeDelay(UNIT_VBLANK, 1, 0);     /* Delay for 5 seconds, printing a */
  100.         FPuts(Output(), " .");            /* dot during each second.         */
  101.         Flush(Output());
  102.     }
  103.  
  104.     TimeDelay(UNIT_VBLANK, 1, 0);
  105.  
  106.     PutStr(" Finished.\n");
  107.     PutStr("Child Process: Signalling main process and exiting.  Bye.\n");
  108.     Flush(Output());
  109.  
  110.     Signal((struct Task *)mainprocess, SIGF_SINGLE);    /* Finished waiting, */
  111.                                                         /* signal the main   */
  112.                                                         /* process and exit  */
  113.                                                         /* child process.    */
  114. }
  115.